#include <string>
#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;


//class BigInt
//{
//public:
//	BigInt()
//	{
//		_val = 0;
//	}
//
//	BigInt(istream& os)
//	{
//		os >> _val;
//	}
//
//	BigInt(const BigInt& other)
//	{
//		_val = other._val;
//	} 
//
//	bool operator < (const BigInt& other)
//	{
//		return this->_val < other._val;
//	}
//
//	bool operator == (const BigInt& other)
//	{
//		return this->_val == other._val;
//	}
//
//	bool IsZero()
//	{
//		return _val == 0;
//	}
//
//	bool IsEven()
//	{
//		return _val % 2 == 0;
//	}
//
//	BigInt DivByTwo()
//	{
//		BigInt r;
//
//		r._val = this->_val / 2;
//
//		return r;
//	}
//
//	BigInt MultiByTwo()
//	{
//		BigInt r;
//
//		r._val = this->_val * 2;
//
//		return r;
//	}
//
//	BigInt operator + (const BigInt& other)
//	{
//		BigInt r;
//
//		r._val = this->_val + other._val;
//
//		return r;
//	}
//
//	BigInt operator - (const BigInt& other)
//	{
//		BigInt r;
//
//		r._val = this->_val - other._val;
//
//		return r;
//	}
//
//	BigInt Mod (const BigInt& other)
//	{
//		BigInt r;
//
//		r._val = this->_val % other._val;
//
//		return r;
//	}
//
//	void Write(ostream& os)
//	{
//		os<<_val;
//	}
//
//private:
//	unsigned __int64 _val;
//};

#define UNIT		1000
#define UNIT_DIGITS	   3
#define UNIT_SLOTS	  10

int TenN (int n)
{
	int r =1;

	for (int i=0; i<n; i++)
	{
		r *= 10;
	}

	return r;
}


class BigInt
{
public:
	BigInt()
	{
		for (int i=0; i<UNIT_SLOTS; i++)
		{
			_val[i] = 0;
		}
	}

	BigInt(istream& os)
	{
		for (int i=0; i<UNIT_SLOTS; i++)
		{
			_val[i] = 0;
		}

		string s;
		os >> s;
		s.reserve();

		for (size_t i=0; i < s.length(); i++)
		{
			int num = s[i] -'0'; 
			int slot = i / UNIT_DIGITS;
			int digit = i % UNIT_DIGITS;

			_val[slot] += num *TenN(digit);
		}
	}

	BigInt(const BigInt& other)
	{
		for (int i=0; i<UNIT_SLOTS; i++)
		{
			_val[i] = other._val[i];
		}
	} 

	bool operator < (const BigInt& other)
	{
		for (int i = UNIT_SLOTS-1; i>=0; i--)
		{
			if (_val[i] < other._val[i])
				return true;
		}

		return false;
	}

	bool operator == (const BigInt& other)
	{
		for (int i=0; i<UNIT_SLOTS; i++)
		{
			if (_val[i] != other._val[i])
				return false;
		}

		return true;
	}

	bool IsZero()
	{
		for (int i=0; i<UNIT_SLOTS; i++)
		{
			if (_val[i] != 0)
				return false;
		}

		return true;
	}

	bool IsEven()
	{
		return (_val[0] % 2) == 0;
	}

	BigInt DivByTwo()
	{
		BigInt r;

		__int64 last =0;
		for (int i = UNIT_SLOTS-1; i>=0; i--)
		{
			last = _val[i] + last *UNIT;
			r._val[i] = last / 2;
			last = last % 2;
		}

		return r;
	}

	BigInt MultiByTwo()
	{
		return (*this) +(*this);
	}

	BigInt operator + (const BigInt& other)
	{
		BigInt r;

		__int64 last =0;
		for (int i=0; i<UNIT_SLOTS; i++)
		{
			last = this->_val[i] + other._val[i] +last;
			r._val[i] = last % UNIT;
			last = last / UNIT;
		}

		return r;
	}

	BigInt operator - (const BigInt& other)
	{
		BigInt r;

		__int64 last =0;
		for (int i=0; i<UNIT_SLOTS; i++)
		{
			last = this->_val[i] - other._val[i] -last;

			if (last>=0)
			{
				r._val[i] = last;
				last = 0;
			}
			else
			{
				r._val[i] = UNIT +last;
				last =1;
			}
		}

		return r;
	}

	BigInt Mod (const BigInt& other)
	{
		BigInt r;

		r._val = this->_val % other._val;

		return r;
	}

	void Write(ostream& os)
	{
		string s;
		bool hasNum = false;

		for (int i = UNIT_SLOTS-1; i>=0; i--)
		{
			__int64 u = _val[i];
				
			for (int j=UNIT_DIGITS-1; i>=0; j--)
			{
				int d = u % (TenN(j));

				if (hasNum || d)
				{
					hasNum = true;
					s += (char)('0' + d );
				}
			}
		}

		if (s.empty())
			s = "0";

		os << s;

	}

private:
	__int64 _val[UNIT_SLOTS];
};

BigInt gcd_Stein(BigInt a, BigInt b)
{
    if (a < b)
	{
		BigInt tmp =a;
		a = b;
		b = tmp;
	}

    if (b.IsZero())
        return a;

    if (a.IsEven() && b.IsEven())
		return gcd_Stein(a.DivByTwo(), b.DivByTwo()).MultiByTwo();

    if (a.IsEven())
        return gcd_Stein(a.DivByTwo(), b);

    if (b.IsEven())
        return gcd_Stein(a, b.DivByTwo());
    
    return gcd_Stein((a + b).DivByTwo(), (a - b).DivByTwo()) ;
}

BigInt gcd(vector<BigInt>& numList)
{
	BigInt d = numList[0];

	for (size_t i=1; i<numList.size(); i++)
	{
		d = gcd_Stein(d, numList[i]);
	}

	return d;
}

void RunFairWarning(const char* fnameIn, const char* fnameOut)
{
	ifstream fin(fnameIn);
	
	int caseCount;
	fin >> caseCount;

	ofstream fout(fnameOut);
	int events;

	for (int i=0; i<caseCount; i++)
	{
		fin >> events;

		vector<BigInt>	numList;
		for (int j=0; j<events; j++)
		{
			numList.push_back(BigInt(fin));
		}

		sort(numList.begin(), numList.end());

		vector<BigInt>	subList;
		for (int j=1; j<events; j++)
		{
			subList.push_back(numList[j] - numList[j-1]);
		}

		BigInt d = gcd(subList);
		BigInt r = numList[0].Mod(d);

		if (!r.IsZero())
		{
			r = d -r;
		}

		fout<<"Case #"<<i+1<<": ";
		r.Write(fout);
		fout<<"\n";
	}
}
